/**
 * API接口封装
 *
 * @author AI Crawlers Team
 * @date 2025-10-10
 */

// 初始化Axios配置
function initAxiosConfig() {
    if (typeof API_CONFIG !== 'undefined') {
        axios.defaults.timeout = API_CONFIG.TIMEOUT;
        axios.defaults.baseURL = API_CONFIG.BASE_URL;
        console.log('Axios配置已初始化，baseURL:', API_CONFIG.BASE_URL);
    }
}

// 立即执行初始化
initAxiosConfig();

// 请求拦截器
axios.interceptors.request.use(
    config => {
        // 确保每次请求都有baseURL
        if (!config.baseURL && typeof API_CONFIG !== 'undefined') {
            config.baseURL = API_CONFIG.BASE_URL;
        }
        console.log('发送请求:', config.method?.toUpperCase(), config.baseURL + config.url);
        return config;
    },
    error => {
        console.error('请求错误：', error);
        return Promise.reject(error);
    }
);

// 响应拦截器
axios.interceptors.response.use(
    response => {
        const res = response.data;
        const url = response.config ? response.config.url : '未知';
        console.log('收到响应:', url, res);
        
        // 检查响应状态
        if (res && res.code === 200) {
            return res;
        } else {
            console.error('业务错误:', res ? res.message : '未知错误');
            return Promise.reject(new Error(res && res.message ? res.message : '请求失败'));
        }
    },
    error => {
        const url = error.config ? error.config.url : '未知';
        const fullUrl = error.config ? (error.config.baseURL || '') + (error.config.url || '') : '未知';
        console.error('响应错误 [' + fullUrl + ']:', error);
        
        let message = '请求失败';
        if (error.response) {
            message = `请求失败：${error.response.status} ${error.response.statusText}`;
            console.error('错误详情:', {
                url: fullUrl,
                status: error.response.status,
                data: error.response.data
            });
        } else if (error.request) {
            message = '网络错误，请检查网络连接';
        } else {
            message = error.message || '请求失败';
        }
        
        return Promise.reject(error);
    }
);

// ================================
// 通用API方法
// ================================
var api = {
    
    /**
     * 确保URL有正确的baseURL前缀
     */
    _ensureBaseUrl(url) {
        // 如果URL已经是完整的URL（http://或https://），直接返回
        if (url.startsWith('http://') || url.startsWith('https://')) {
            return url;
        }
        // 如果URL已经包含/api前缀，直接返回
        if (url.startsWith('/api/')) {
            return url;
        }
        // 否则，添加baseURL前缀
        const baseURL = axios.defaults.baseURL || API_CONFIG.BASE_URL;
        return baseURL + url;
    },
    
    /**
     * GET请求
     */
    get(url, params) {
        return axios.get(this._ensureBaseUrl(url), { params });
    },
    
    /**
     * POST请求
     */
    post(url, data) {
        return axios.post(this._ensureBaseUrl(url), data);
    },
    
    /**
     * PUT请求
     */
    put(url, data) {
        return axios.put(this._ensureBaseUrl(url), data);
    },
    
    /**
     * DELETE请求
     */
    delete(url) {
        return axios.delete(this._ensureBaseUrl(url));
    },
    
    /**
     * 上传文件
     */
    upload(url, file, onProgress) {
        const formData = new FormData();
        formData.append('file', file);
        
        return axios.post(this._ensureBaseUrl(url), formData, {
            headers: {
                'Content-Type': 'multipart/form-data'
            },
            onUploadProgress: onProgress
        });
    }
};

// ================================
// 问句API
// ================================
var questionApi = {
    
    /**
     * 获取问句列表（分页）
     */
    getList(params) {
        return api.get('/questions', params);
    },
    
    /**
     * 获取问句详情
     */
    getById(id) {
        return api.get(`/questions/${id}`);
    },
    
    /**
     * 创建问句
     */
    create(data) {
        return api.post('/questions', data);
    },
    
    /**
     * 更新问句
     */
    update(id, data) {
        return api.put(`/questions/${id}`, data);
    },
    
    /**
     * 删除问句
     */
    delete(id) {
        return api.delete(`/questions/${id}`);
    },
    
    /**
     * 批量删除问句
     */
    batchDelete(ids) {
        return api.delete('/questions/batch', { data: ids });
    },
    
    /**
     * 批量导入问句
     */
    batchImport(file, onProgress) {
        return api.upload('/questions/import', file, onProgress);
    },
    
    /**
     * 获取所有问句类别
     */
    getAllCategories() {
        return api.get('/questions/categories');
    },
    
    // ==================== 问句-产品关联 ====================
    
    /**
     * 获取问句关联的产品
     */
    getRelatedProducts(questionId) {
        return api.get(`/questions/${questionId}/products`);
    },
    
    /**
     * 添加问句-产品关联
     */
    addProductRelation(questionId, data) {
        return api.post(`/questions/${questionId}/products`, data);
    },
    
    /**
     * 批量设置问句的产品关联
     */
    batchSetProductRelations(questionId, relations) {
        return api.put(`/questions/${questionId}/products/batch`, relations);
    },
    
    /**
     * 移除问句-产品关联
     */
    removeProductRelation(questionId, productId) {
        return api.delete(`/questions/${questionId}/products/${productId}`);
    },
    
    /**
     * 根据产品ID查询关联的问句ID列表
     */
    getQuestionIdsByProduct(productId) {
        return api.get(`/questions/by-product/${productId}`);
    },
    
    // ==================== 问句-类别关联 ====================
    
    /**
     * 获取问句关联的产品类别
     */
    getRelatedProductCategories(questionId) {
        return api.get(`/questions/${questionId}/product-categories`);
    },
    
    /**
     * 添加问句-类别关联
     */
    addCategoryRelation(questionId, data) {
        return api.post(`/questions/${questionId}/product-categories`, data);
    },
    
    /**
     * 批量设置问句的类别关联
     */
    batchSetCategoryRelations(questionId, relations) {
        return api.put(`/questions/${questionId}/product-categories/batch`, relations);
    },
    
    /**
     * 移除问句-类别关联
     */
    removeCategoryRelation(questionId, categoryId) {
        return api.delete(`/questions/${questionId}/product-categories/${categoryId}`);
    },
    
    /**
     * 根据类别查询关联的问句ID列表
     */
    getQuestionIdsByCategory(categoryName) {
        return api.get(`/questions/by-category/${categoryName}`);
    },
    
    /**
     * 批量获取问句详情
     */
    batchGet(questionIds) {
        return api.post('/questions/batch-get', { questionIds });
    }
};

// ================================
// 产品类别API
// ================================
var categoryApi = {
    
    /**
     * 获取所有类别
     */
    getAll() {
        return api.get('/categories');
    },
    
    /**
     * 获取类别列表（分页）
     */
    getList(page = 1, size = 100) {
        return api.get('/categories', { page, size });
    },
    
    /**
     * 获取类别树
     */
    getTree() {
        return api.get('/categories/tree');
    },
    
    /**
     * 获取类别详情
     */
    getById(id) {
        return api.get(`/categories/${id}`);
    },
    
    /**
     * 创建类别
     */
    create(data) {
        return api.post('/categories', data);
    },
    
    /**
     * 更新类别
     */
    update(id, data) {
        return api.put(`/categories/${id}`, data);
    },
    
    /**
     * 删除类别
     */
    delete(id) {
        return api.delete(`/categories/${id}`);
    },
    
    /**
     * 批量删除类别
     */
    batchDelete(ids) {
        return axios.delete('/categories/batch', { data: ids });
    },
    
    /**
     * 获取子类别
     */
    getChildren(parentId) {
        return api.get('/categories/children', { parentId });
    }
};

// ================================
// 产品API
// ================================
var productApi = {
    
    /**
     * 获取产品列表（分页）
     */
    getList(params) {
        return api.get('/products', params);
    },
    
    /**
     * 获取产品详情
     */
    getById(id) {
        return api.get(`/products/${id}`);
    },
    
    /**
     * 创建产品
     */
    create(data) {
        return api.post('/products', data);
    },
    
    /**
     * 更新产品
     */
    update(id, data) {
        return api.put(`/products/${id}`, data);
    },
    
    /**
     * 删除产品
     */
    delete(id) {
        return api.delete(`/products/${id}`);
    },
    
    /**
     * 批量删除产品
     */
    batchDelete(ids) {
        return api.delete('/products/batch', { data: ids });
    },
    
    /**
     * 批量导入产品
     */
    batchImport(file, onProgress) {
        return api.upload('/products/import', file, onProgress);
    },
    
    /**
     * 获取所有产品类别
     */
    getAllCategories() {
        return api.get('/products/categories');
    },
    
    /**
     * 获取所有品牌
     */
    getAllBrands() {
        return api.get('/products/brands');
    },
    
    /**
     * 获取产品的竞品列表
     */
    getCompetitors(productId, competitorType, strength) {
        return api.get(`/products/${productId}/competitors`, { competitorType, strength });
    },
    
    /**
     * 添加竞品关联
     */
    addCompetitor(productId, data) {
        return api.post(`/products/${productId}/competitors`, data);
    },
    
    /**
     * 移除竞品关联
     */
    removeCompetitor(productId, competitorId) {
        return api.delete(`/products/${productId}/competitors/${competitorId}`);
    },
    
    /**
     * 批量配置竞品
     */
    batchConfigCompetitors(productId, competitors) {
        return api.put(`/products/${productId}/competitors/batch`, competitors);
    }
};

// ================================
// 竞品API（复用产品API）
// ================================
var competitorApi = {
    
    /**
     * 获取竞品列表（分页）
     * 自动添加 isOurProduct=0 条件
     */
    getList(params) {
        return productApi.getList({ ...params, isOurProduct: 0 });
    },
    
    /**
     * 获取竞品详情
     */
    getById(id) {
        return productApi.getById(id);
    },
    
    /**
     * 创建竞品
     */
    create(data) {
        return productApi.create({ ...data, isOurProduct: 0 });
    },
    
    /**
     * 更新竞品
     */
    update(id, data) {
        return productApi.update(id, { ...data, isOurProduct: 0 });
    },
    
    /**
     * 删除竞品
     */
    delete(id) {
        return productApi.delete(id);
    },
    
    /**
     * 批量删除竞品
     */
    batchDelete(ids) {
        return productApi.batchDelete(ids);
    },
    
    /**
     * 获取我方产品的竞品列表
     */
    getCompetitorsByOurProduct(ourProductId) {
        return api.get(`/products/${ourProductId}/competitors`);
    },
    
    /**
     * 获取关注该竞品的我方产品列表（反向查询）
     */
    getOurProductsByCompetitor(competitorId) {
        return api.get(`/products/competitor/${competitorId}/our-products`);
    }
};

// ================================
// 采集任务API
// ================================
var taskApi = {
    /**
     * 获取任务列表
     */
    getList(page = 1, size = 10, status = '') {
        const params = { page, size };
        if (status) params.status = status;
        return api.get('/collect-tasks', params);
    },
    
    /**
     * 创建任务
     */
    create(data) {
        return api.post('/collect-tasks', data);
    },
    
    /**
     * 获取任务详情
     */
    getDetail(id) {
        return api.get(`/collect-tasks/${id}`);
    },
    
    /**
     * 获取未执行的问句（断点续传）
     */
    getPendingQuestions(id) {
        return api.get(`/collect-tasks/${id}/pending-questions`);
    },
    
    /**
     * 取消任务
     */
    cancel(id) {
        return api.put(`/collect-tasks/${id}/cancel`);
    },
    
    /**
     * 删除任务
     */
    delete(id) {
        return api.delete(`/collect-tasks/${id}`);
    }
};

// ================================
// 采集数据上报API
// ================================
var collectApi = {
    /**
     * 上报单个结果
     */
    submitResult(data) {
        return api.post('/collect/submit', data);
    },
    
    /**
     * 批量上报结果
     */
    batchSubmitResults(data) {
        return api.post('/collect/batch-submit', data);
    }
};

// ================================
// 采集结果API
// ================================
var resultApi = {
    /**
     * 获取任务的所有结果
     */
    getByTask(taskId) {
        return api.get(`/collect-results/task/${taskId}`);
    },
    
    /**
     * 对比查询（同一问句多平台）
     */
    compare(taskId, questionId) {
        return api.get('/collect-results/compare', { taskId, questionId });
    },
    
    /**
     * 删除结果
     */
    delete(id) {
        return api.delete(`/collect-results/${id}`);
    }
};

// ================================
// 分析API（待实现）
// ================================
var analysisApi = {
    
    getDashboard() {
        return api.get('/analysis/dashboard');
    },
    
    getCompetitor(params) {
        return api.get('/analysis/competitor', params);
    }
};

